home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / lists / mint / l_1599 / 1554 < prev    next >
Encoding:
Internet Message Format  |  1994-08-27  |  30.8 KB
  1. Subject: Re: MiNT 1.10 re-sync
  2. Date: Thu, 9 Jun 94 20:35:06 CDT
  3. From: Juergen Lock <nox@jelal.north.de>
  4. In-Reply-To: <9406080703.AA15701@hera.rbi.informatik.uni-frankfurt.de>; from "Kay Roemer" at Jun 8, 94 9:03 am
  5. Message-Id: <9406091835.AA00187@jelal.north.de>
  6.  
  7. Kay Roemer writes:
  8.  
  9. > > Upon reflection, it would probably be easier to load shared text regions at the
  10. > > top of memory, and continue creating the TPA from lower memory. That way you
  11. > > don't have to worry about artificially limiting the amount of memory you give
  12. > > to a newly spawned process. (I wonder how topdown solved this problem...)
  13. > 
  14. > This sounds like a possible solution.
  15.  
  16.  hmm i don't know, doesn't falcons need free space at top when changing
  17. screen size (s_realloc)?
  18.  
  19. >  TPA doesn't matter in this case, because
  20. > it is freed when the process (running a shared text) exits. Fragmentation seems
  21. > to occur, when
  22. > 
  23. > 1) running shared text
  24. > 2) last process running shared text exits, shared text still hangs around.
  25. > 3) allocating memory in eg, a device driver or fs or running TSR or daemon.
  26.  
  27.  and when MiNT needs a new nalloc arena...
  28.  
  29. > 4) goto 1
  30. > 
  31. > After a few iterations the stuff allocated in 3) prevents the free shared
  32. > text regions from beeing joined together to one large hunk.
  33. > 
  34. > Sigh! Thats a real problem when physical address space == virtual address
  35. > space.
  36.  
  37.  yes :-(
  38. > 
  39. > Kay.
  40.  
  41.  ok here is what i've been testing the last few weeks.  works for me
  42. although there could still be bugs that only show up on 68030, etc.
  43. but first a few other fixes to add to Michaels collection. :)
  44.  
  45. 0. this was missing:  use new value for TIOCSETP and keep old for
  46. TIOCSETN, other way around can hang old binaries...
  47.  
  48. Index: file.h
  49. @@ -340,7 +341,7 @@
  50.  #define FIONREAD    (('F'<< 8) | 1)
  51.  #define FIONWRITE    (('F'<< 8) | 2)
  52.  #define TIOCGETP    (('T'<< 8) | 0)
  53. -#define TIOCSETP    (('T'<< 8) | 1)
  54. +#define TIOCSETN    (('T'<< 8) | 1)
  55.  #define TIOCGETC    (('T'<< 8) | 2)
  56.  #define TIOCSETC    (('T'<< 8) | 3)
  57.  #define TIOCGLTC    (('T'<< 8) | 4)
  58. @@ -361,7 +362,7 @@
  59.  #define TIOCGFLAGS    (('T'<< 8) | 22)
  60.  #define TIOCSFLAGS    (('T'<< 8) | 23)
  61.  #define TIOCOUTQ    (('T'<< 8) | 24)
  62. -#define TIOCSETN    (('T'<< 8) | 25)
  63. +#define TIOCSETP    (('T'<< 8) | 25)
  64.  
  65.  /* cursor control Fcntls:
  66.   * NOTE THAT THESE MUST BE TOGETHER
  67.  
  68. 1. getcwd crashed when called from `unmounted' (Dlock) fs...
  69.  
  70. Index: unifs.c
  71. @@ -379,6 +379,10 @@
  72.          return EINTRN;
  73.      }
  74.  
  75. +    if (!fs) {
  76. +        *pathname = 0;
  77. +        return 0;
  78. +    }
  79.      if (!(fs->fsflags & FS_LONGPATH)) {
  80.          r = (*fs->getname)(&curproc->root[dir->dev], dir, tmppath, PATH_MAX);
  81.          if (r) return r;
  82.  
  83. 2. ls -l /pipe: fix pty modes (S_IFCHR) and 14-char names
  84.  
  85. Index: pipefs.c
  86. @@ -477,11 +477,12 @@
  87.          outp->readers = 1; outp->writers = selfread ? 1 : VIRGIN_PIPE;
  88.          outp->wsel = outp->rsel = 0;
  89.      }
  90. +    b->name[NAME_MAX] = '\0';
  91.      strncpy(b->name, name, NAME_MAX);
  92.      b->time = timestamp;
  93.      b->date = datestamp;
  94.      b->dosflags = attrib;
  95. -    b->mode = ((attrib & FA_SYSTEM) ? S_IFCHR : S_IFIFO) | mode;
  96. +    b->mode = ((attrib & FA_SYSTEM) ? S_IFCHR : S_IFIFO) | (mode & ~S_IFMT);
  97.      b->uid = curproc->ruid;
  98.      b->gid = curproc->rgid;
  99.  
  100. 3. make echo >pipe/pty work when other end already open, only fail if
  101. O_EXCL or Fcreate attr != 0. (shells often creat() output redirection...)
  102.  
  103. Index: dosfile.c
  104. @@ -34,7 +35,7 @@
  105.      unsigned perm;
  106.      int creating;
  107.      char temp1[PATH_MAX];
  108. -    extern FILESYS proc_filesys;
  109. +    extern FILESYS proc_filesys, pipe_filesys;
  110.  
  111.  /* for special BIOS "fake" devices */
  112.      extern DEVDRV fakedev;
  113. @@ -59,9 +60,12 @@
  114.  
  115.  /*
  116.   * file found: this is an error if (O_CREAT|O_EXCL) are set
  117. + *    ...or if this is Fcreate with nonzero attr on the pipe filesystem
  118.   */
  119.  
  120. -    if ( (r == 0) && ( (rwmode & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL) ) ) {
  121. +    if ( (r == 0) && ( (rwmode & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL) ||
  122. +            (attr && fc.fs == &pipe_filesys &&
  123. +            (rwmode & (O_CREAT|O_TRUNC)) == (O_CREAT|O_TRUNC)))) {
  124.          DEBUG(("do_open(%s): file already exists",name));
  125.          mint_errno = EACCDN;
  126.          release_cookie(&fc);
  127. Index: pipefs.c
  128. @@ -544,10 +545,12 @@
  129.          }
  130.          p->flags &= ~O_HEAD;
  131.      } else {
  132. +#if 0
  133.          if (f->flags & O_TRUNC) {
  134.              DEBUG(("pipe_open: fifo already exists"));
  135.              return EACCDN;
  136.          }
  137. +#endif
  138.      }
  139.  /*
  140.   * check for file sharing compatibility. note that O_COMPAT gets mutated
  141.  
  142. 4. save a long read
  143.  
  144. Index: intr.spp
  145. @@ -42,7 +42,7 @@
  146.  _mint_5ms:
  147.      move.l    a0,-(sp)
  148.      lea    _uptimetick,a0
  149. -    tst.l    _uptimetick
  150. +    tst.l    (a0)
  151.      bne.s    L_no_uptime
  152.      move.l    #200,(a0)
  153.  L_no_uptime:
  154.  
  155. 5. fork() doesn't copy shared text regions so why allocate memory
  156. to save them :)
  157.  
  158. Index: dosmem.c
  159. @@ -1283,6 +1294,15 @@
  160.      if (save) {
  161.          TRACE(("do_vfork: saving parent"));
  162.          savesize = memused(curproc) - txtsize;
  163. +        if (!txtsize && (p->base->p_flags & F_SHTEXT)) {
  164. +            for (i = 0; i < curproc->num_reg; i++) {
  165. +                m = curproc->mem[i];
  166. +                if (m && (m->mflags & M_SHTEXT)) {
  167. +                    savesize -= m->len;
  168. +                    break;
  169. +                }
  170. +            }
  171. +        }
  172.          assert(savesize >= 0);
  173.  
  174.          saveplace = (char *)alloc_region(alt, savesize, PROT_P);
  175.  
  176. 6. and now the sticky text/fragmentation megapatch...  does a few things:
  177.  
  178. . if F_ALTLOAD|F_SHTEXT look at F_MINALT bits to see how much memory
  179. the new process needs and free sticky text regions if necessary, all
  180. F_MINALT bits set (0xf0000000) means `as much as you can get'
  181. . execv..() frees the old process memory before allocating the new ones,
  182. and so no longer leaves holes in your memory map.  this took a few
  183. ugly hacks but i think its worth it :)  the only visible change should
  184. be when exec'ing a damaged binary the process gets killed, fixing that
  185. would require reading executables twice.
  186. . check the sticky bit, just making everything sharable sticky still got
  187. me too much `out of memory's...  and free sticky text regions after disk
  188. changes or if open() would otherwise fail.
  189. . also free no more sticky text regions then necessary in alloc, and
  190. some other small changes.
  191.  
  192.  oh and if you need something to adjust the F_MINALT bits...
  193.  
  194. #! /usr/bin/perl
  195. # xsetf [-xhex] files ... -- print/set executable flags
  196. #
  197. $aexec = 's L L L L L L S';
  198. #     short    a_magic;    /* magic number */
  199. #unsigned long    a_text;        /* size of text segment */
  200. #unsigned long    a_data;        /* size of initialized data */
  201. #unsigned long    a_bss;        /* size of uninitialized data */
  202. #unsigned long    a_syms;        /* size of symbol table */
  203. #unsigned long    a_AZero1;    /* always zero */
  204. #unsigned long    a_ldflgs;    /* program load flags */
  205. #unsigned short    a_isreloc;    /* is reloc info present */
  206.  
  207. while ($_ = $ARGV[0], /^-/) {
  208.     shift;
  209.     last if /^--$/;
  210.     if (/^-x(.*)/) {
  211.         if ($1) {
  212.             $x = $1;
  213.         } else {
  214.             $x = shift;
  215.             next;
  216.         }
  217.     }
  218. }
  219. foreach (@ARGV) {
  220.     print $_, ":\t";
  221.     open (F, "+< $_") || die "Can't open";
  222.     sysread (F, $head, length (pack ($aexec, 0))) || die "Can't read header";
  223.     ($a_magic, $a_text, $a_data, $a_bss, $a_syms,
  224.         $a_AZero1, $a_ldflgs, $a_isreloc) = unpack ($aexec, $head);
  225.     die "not executable/corrupted header" unless $a_magic == 0x601a;
  226.     seek (F, 0, 0) || die "Can't seek back";
  227.     print "\n text ", $a_text, " data ", $a_data, " bss ", $a_bss, " symbols ",
  228.             $a_syms, " zero1 ", $a_AZero1, " isreloc ", $a_isreloc, "\n";
  229.     printf "\tldflags\t\t0x%08lx\n", $a_ldflgs;
  230.  
  231.     printf "\t &fload\t\t0x%08lx\n", 1    if ($a_ldflgs&1);
  232.     printf "\t &altload\t0x%08lx\n", 2    if ($a_ldflgs&2);
  233.     printf "\t &altalloc\t0x%08lx\n",4    if ($a_ldflgs&4);
  234.     printf "\t &prot_p\t0x%08lx = 0x%08lx\n",    0xf0,  0
  235.                         if (!($a_ldflgs&0xf0));
  236.     printf "\t &prot_g\t0x%08lx = 0x%08lx\n",    0xf0,  0x10
  237.                         if (($a_ldflgs&0xf0) == 0x10);
  238.     printf "\t &prot_s\t0x%08lx = 0x%08lx\n",    0xf0,  0x20
  239.                         if (($a_ldflgs&0xf0) == 0x20);
  240.     printf "\t &prot_pr\t0x%08lx = 0x%08lx\n",    0xf0,  0x30
  241.                         if (($a_ldflgs&0xf0) == 0x30);
  242.     printf "\t &prot_i\t0x%08lx = 0x%08lx\n",    0xf0,  0x40
  243.                         if (($a_ldflgs&0xf0) == 0x40);
  244.     printf "\t &prot_??\t0x%08lx = 0x%08lx\n",    0xf0, $a_ldflgs&0xf0
  245.                         if (($a_ldflgs&0xf0) > 0x40);
  246.     printf "\t &shtext\t0x%08lx\n",  0x800 if ($a_ldflgs&0x800);
  247.     printf "\t &minalt\t0x%08lx = 0x%08lx\n",    0xf0000000,
  248.             $a_ldflgs&0xf0000000    if ($a_ldflgs&0xf0000802);
  249.     if (defined ($x)) {
  250.         $x = oct ($x) if $x =~ /^0/;
  251.         $a_ldflgs = $x;
  252.     }
  253.     $newhead = pack ($aexec, $a_magic, $a_text, $a_data, $a_bss, $a_syms,
  254.         $a_AZero1, $a_ldflgs, $a_isreloc);
  255.     if ($newhead ne $head) {
  256.         syswrite (F, $newhead, length ($newhead)) == length ($newhead)
  257.             || die "Can't write back header";
  258.     }
  259.     close F || die "Can't close";
  260. }
  261. -------cut----
  262.  
  263.  the sticky bit is of course chmod +t.  (if your /bin/sh still is on
  264. GEMDOS change it now... :)  and then see you no longer need _shell_p.)
  265.  
  266. Index: dosfile.c
  267. @@ -9,6 +9,7 @@
  268.  #include "mint.h"
  269.  
  270.  extern char vt52xkey[];
  271. +MEMREGION *tofreed;    /* to-be-freed shared text region (set in denyshare) */
  272.  
  273.  static long do_dup P_((int,int));
  274.  static void unselectme P_((PROC *));
  275. @@ -232,6 +236,12 @@
  276.          dispose_fileptr(f);
  277.          return NULL;
  278.      }
  279. +
  280. +    if (tofreed) {
  281. +        tofreed->links = 0;
  282. +        free_region(tofreed);
  283. +        tofreed = 0;
  284. +    }
  285.  
  286.  /* special code for opening a tty */
  287.      if (is_terminal(f)) {
  288. Index: dosmem.c
  289. @@ -53,7 +53,7 @@
  290.      long maxsize, mleft;
  291.  
  292.      if (size == -1L) {
  293. -        maxsize = max_rsize(map);
  294. +        maxsize = max_rsize(map, 0L);
  295.          if (curproc->maxmem) {
  296.              mleft = curproc->maxmem - memused(curproc);
  297.              if (maxsize > mleft)
  298. @@ -420,6 +420,33 @@
  299.          }
  300.      }
  301.  
  302. +/* make a local copy of the name, in case we are overlaying the current
  303. + * process
  304. + */
  305. +    if (mkname) {
  306. +        lastslash = 0;
  307. +        newname = ptr1;
  308. +        while (*newname) {
  309. +            if (*newname == '\\' || *newname == '/')
  310. +                lastslash = newname;
  311. +            ++newname;
  312. +        }
  313. +        if (!lastslash)
  314. +            lastslash = ptr1;
  315. +        else
  316. +            lastslash++;
  317. +
  318. +        i = 0; newname = localname;
  319. +        while (i++ < PNAMSIZ) {
  320. +            if (*lastslash == '.' || *lastslash == 0) {
  321. +                *newname = 0; break;
  322. +            }
  323. +            else
  324. +                *newname++ = *lastslash++;
  325. +        }
  326. +        *newname = 0;
  327. +    }
  328. +
  329.  TRACE(("creating environment"));
  330.  
  331.      if (mkload || mkbase) {
  332. @@ -434,7 +461,7 @@
  333.  TRACE(("creating base page"));
  334.  
  335.      if (mkbase) {
  336. -        base = create_base((char *)ptr2, env, flags, 0L);
  337. +        base = create_base((char *)ptr2, env, flags, 0L, 0L, 0L, 0L, 0L, 0L);
  338.          if (!base) {
  339.              DEBUG(("Pexec: unable to create basepage"));
  340.              detach_region(curproc, env);
  341. @@ -444,8 +471,19 @@
  342.  TRACELOW(("Pexec: basepage region(%lx) is %ld bytes at %lx", base, base->len, base->loc));
  343.      }
  344.      else if (mkload) {
  345. -        base = load_region((char *)ptr1, env, (char *)ptr2,
  346. -            &xattr, &text, &flags);
  347. +        char cbuf[128], *tail = ptr2;
  348. +        if (overlay) {
  349. +            static char fbuf[PATH_MAX];
  350. +            ptr1 = strncpy (fbuf, ptr1, PATH_MAX-2);
  351. +            tail = strncpy (cbuf, ptr2, 127);
  352. +        }
  353. +#if 0
  354. +        base = load_region((char *)ptr1, env, (char *)tail,
  355. +            &xattr, &text, &flags, 0);
  356. +#else
  357. +        base = load_region((char *)ptr1, env, (char *)tail,
  358. +            &xattr, &text, &flags, overlay);
  359. +#endif
  360.          if (!base) {
  361.              DEBUG(("Pexec: load_region failed"));
  362.              detach_region(curproc, env);
  363. @@ -480,33 +518,6 @@
  364.  #endif
  365.      }
  366.  
  367. -/* make a local copy of the name, in case we are overlaying the current
  368. - * process
  369. - */
  370. -    if (mkname) {
  371. -        lastslash = 0;
  372. -        newname = ptr1;
  373. -        while (*newname) {
  374. -            if (*newname == '\\' || *newname == '/')
  375. -                lastslash = newname;
  376. -            ++newname;
  377. -        }
  378. -        if (!lastslash)
  379. -            lastslash = ptr1;
  380. -        else
  381. -            lastslash++;
  382. -
  383. -        i = 0; newname = localname;
  384. -        while (i++ < PNAMSIZ) {
  385. -            if (*lastslash == '.' || *lastslash == 0) {
  386. -                *newname = 0; break;
  387. -            }
  388. -            else
  389. -                *newname++ = *lastslash++;
  390. -        }
  391. -        *newname = 0;
  392. -    }
  393. -
  394.      if (mkload || mkbase) {
  395.          /*
  396.           * Now that the file's loaded, flags is set to the prgflags
  397. @@ -846,7 +857,7 @@
  398.     memory runs low. Assume that we will never have 65535 processes
  399.     using a particular memory region. */
  400.                  if (m->links == 0) {
  401. -                    if (m->mflags & M_SHTEXT)
  402. +                    if (m->mflags & M_SHTEXT_T)
  403.                          m->links = 0xffff;
  404.                      else
  405.                          free_region(m);
  406. @@ -1307,9 +1327,10 @@
  407.          }
  408.          savemem = addr2mem((virtaddr)saveplace);
  409.          assert(savemem);
  410. +        savemem->mflags |= M_FSAVED;
  411.          for (i = 0; i < curproc->num_reg; i++) {
  412.              m = curproc->mem[i];
  413. -            if (m && m != savemem && !(m->mflags & M_SHTEXT)) {
  414. +            if (m && !(m->mflags & (M_FSAVED|M_SHTEXT))) {
  415.                  if (i != 1 || txtsize == 0) {
  416.                      quickmove(saveplace, (char *)m->loc, m->len);
  417.                      saveplace += m->len;
  418. @@ -1354,23 +1375,7 @@
  419.      TRACE(("do_vfork: parent waking up"));
  420.  
  421.      if (save) {
  422. -        TRACE(("do_vfork: parent restoring memory"));
  423. -        saveplace = (char *)savemem->loc;
  424. -        for (i = 0; i < curproc->num_reg; i++) {
  425. -            m = curproc->mem[i];
  426. -            if (m && (m != savemem) && !(m->mflags & M_SHTEXT)) {
  427. -                if (i != 1 || txtsize == 0) {
  428. -                    quickmove((char *)m->loc, saveplace, m->len);
  429. -                    saveplace += m->len;
  430. -                }
  431. -                else {
  432. -                    quickmove((char *)m->loc+txtsize, saveplace,
  433. -                    m->len - txtsize);
  434. -                    saveplace += m->len - txtsize;
  435. -                }
  436. -            }
  437. -        }
  438. -        detach_region(curproc, savemem);
  439. +        fork_restore(curproc, 0L);
  440.      }
  441.      curproc->sigmask = sigmask;
  442.  /* note that the PROC structure pointed to by p may be freed during
  443. @@ -1380,6 +1385,50 @@
  444.      check_sigs();    /* did we get any signals while sleeping? */
  445.      return newpid;
  446.  }
  447. +
  448. +/*
  449. + * fork_restore(p): restore process memory after a blocking fork
  450. + */
  451. +
  452. +void fork_restore(p, savemem)
  453. +PROC *p;
  454. +MEMREGION *savemem;
  455. +{
  456. +    MEMREGION *m;
  457. +    long txtsize = p->txtsize;
  458. +    char *saveplace;
  459. +    int i;
  460. +
  461. +    if (!savemem) {
  462. +        for (i = 0; i < p->num_reg; i++) {
  463. +            m = p->mem[i];
  464. +            if (m && (m->mflags & M_FSAVED)) {
  465. +                savemem = m;
  466. +                break;
  467. +            }
  468. +        }
  469. +        if (!savemem)
  470. +            return;
  471. +    }
  472. +    saveplace = (char *)savemem->loc;
  473. +
  474. +    TRACE(("do_vfork: parent restoring memory"));
  475. +    for (i = 0; i < p->num_reg; i++) {
  476. +        m = p->mem[i];
  477. +        if (m && !(m->mflags & (M_FSAVED|M_SHTEXT))) {
  478. +            if (i != 1 || txtsize == 0) {
  479. +                quickmove((char *)m->loc, saveplace, m->len);
  480. +                saveplace += m->len;
  481. +            }
  482. +            else {
  483. +                quickmove((char *)m->loc+txtsize, saveplace,
  484. +                m->len - txtsize);
  485. +                saveplace += m->len - txtsize;
  486. +            }
  487. +        }
  488. +    }
  489. +    detach_region(p, savemem);
  490. +}
  491.  
  492.  /*
  493.   * here are the interfaces that the user sees. Pvfork() doesn't save
  494. Index: filesys.c
  495. @@ -367,7 +367,7 @@
  496.      int i;
  497.      FILEPTR *f;
  498.      FILESYS *fs;
  499. -    SHTEXT *stext;
  500. +    SHTEXT *stext, **old;
  501.      extern SHTEXT *text_reg;    /* in mem.c */
  502.      DIR *dirh;
  503.      fcookie dir;
  504. @@ -461,13 +461,25 @@
  505.      }
  506.  
  507.  /* free any file descriptors associated with shared text regions */
  508. -    for (stext = text_reg; stext; stext = stext->next) {
  509. +    for (old = &text_reg; (stext = *old);) {
  510.          f = stext->f;
  511.          if (f->fc.dev == d) {
  512.              f->dev = NULL;
  513.              do_pclose(rootproc, f);
  514.              stext->f = 0;
  515. +/* free region if unattached */
  516. +            if (stext->text->links == 0xffff) {
  517. +                stext->text->links = 0;
  518. +                stext->text->mflags &= ~(M_SHTEXT|M_SHTEXT_T);
  519. +                free_region(stext->text);
  520. +                *old = stext->next;
  521. +                kfree(stext);
  522. +                continue;
  523. +            }
  524. +/* else clear `sticky bit' */
  525. +            stext->text->mflags &= ~M_SHTEXT_T;
  526.          }
  527. +        old = &stext->next;
  528.      }
  529.  }
  530.  
  531. @@ -979,6 +991,8 @@
  532.  {
  533.      int newrm, newsm;    /* new read and sharing mode */
  534.      int oldrm, oldsm;    /* read and sharing mode of already opened file */
  535. +    extern MEMREGION *tofreed;
  536. +    MEMREGION *m = tofreed;
  537.      int i;
  538.  
  539.      newrm = f->flags & O_RWMODE;
  540. @@ -999,6 +1013,12 @@
  541.          oldsm = list->flags & O_SHMODE;
  542.          if (oldsm == O_DENYW || oldsm == O_DENYRW) {
  543.               if (newrm != O_RDONLY) {
  544. +/* conflict because of unattached shared text region? */
  545. +                if (!m && (m = find_text_seg(list))) {
  546. +                    if (m->links == 0xffff)
  547. +                        continue;
  548. +                    m = 0;
  549. +                }
  550.                  DEBUG(("write access denied"));
  551.                  return 1;
  552.              }
  553. @@ -1040,6 +1060,9 @@
  554.              ;    /* everything is OK */
  555.          }
  556.      }
  557. +/* cannot close shared text regions file here... have open do it. */
  558. +    if (m)
  559. +        tofreed = m;
  560.      return 0;
  561.  }
  562.  
  563. Index: mem.c
  564. @@ -576,7 +576,7 @@
  565.      ulong size;
  566.      int mode;
  567.  {
  568. -    MEMREGION *m, *n, *s;
  569. +    MEMREGION *m, *n, *nlast, *nfirstp, *s;
  570.  
  571.      TRACELOW(("get_region(%s,%lx,%x)",
  572.          (map == ker ? "ker" : (map == core ? "core" : "alt")),
  573. @@ -601,10 +601,12 @@
  574.  /* We come back and try again if we found and freed any unattached shared
  575.   * text regions.
  576.   */
  577. +    nfirstp = NULL;
  578.  retry:
  579. -    s = NULL;
  580. -
  581.      n = *map;
  582. +retry2:
  583. +    s = nlast = NULL;
  584. +
  585.      while (n) {
  586.          if (ISFREE(n)) {
  587.              if (n->len == size) {
  588. @@ -628,10 +630,13 @@
  589.                      return 0;
  590.                  }
  591.              }
  592. +            nlast = n;
  593.  /* If this is an unattached shared text region, leave it as a last resort */
  594.          } else if (n->links == 0xffff && (n->mflags & M_SHTEXT)) {
  595. -            if (!s)
  596. +            if (!s) {
  597.                  s = n;
  598. +                nfirstp = nlast;
  599. +            }
  600.          }
  601.          n = n->next;
  602.      }
  603. @@ -639,11 +644,60 @@
  604.  /* Looks like we're out of free memory. Try freeing an unattached shared text
  605.   * region, and then try again to fill this request.
  606.   */
  607. +#if 1
  608. +    if (s && s->len < size) {
  609. +        long lastsize = 0, end = 0;
  610. +
  611. +        n = nlast = nfirstp;
  612. +        if (!n || n->next != s)
  613. +            n = s;
  614. +        for (; n; n = n->next) {
  615. +            if (ISFREE(n)) {
  616. +                if (end == n->loc) {
  617. +                    lastsize += n->len;
  618. +                } else {
  619. +                    s = NULL;
  620. +                    nfirstp = nlast;
  621. +                    lastsize = n->len;
  622. +                }
  623. +                nlast = n;
  624. +                end = n->loc + n->len;
  625. +                if (lastsize >= size) {
  626. +                    break;
  627. +                }
  628. +            } else if (n->links == 0xffff && (n->mflags & M_SHTEXT)) {
  629. +                if (end == n->loc) {
  630. +                    if (!s)
  631. +                        s = n;
  632. +                    lastsize += n->len;
  633. +                } else {
  634. +                    s = n;
  635. +                    nfirstp = nlast;
  636. +                    lastsize = n->len;
  637. +                }
  638. +                end = n->loc + n->len;
  639. +                if (lastsize >= size) {
  640. +                    break;
  641. +                }
  642. +            }
  643. +        }
  644. +        if (!n)
  645. +            s = NULL;
  646. +    }
  647. +    if (s) {
  648. +        s->links = 0;
  649. +        free_region(s);
  650. +        if (!(n = nfirstp))
  651. +            n = *map;
  652. +        goto retry2;
  653. +    }
  654. +#else
  655.      if (s) {
  656.          s->links = 0;
  657.          free_region(s);
  658.          goto retry;
  659.      }
  660. +#endif
  661.          
  662.      if (m)
  663.          dispose_region(m);
  664. @@ -836,6 +890,7 @@
  665.      return 0;
  666.  }
  667.  
  668. +#if 0
  669.  /*
  670.   * max_rsize(map): return the length of the biggest free region
  671.   * in the given memory map, or 0 if no regions remain.
  672. @@ -879,6 +934,84 @@
  673.      }
  674.      return size;
  675.  }
  676. +#else
  677. +/*
  678. + * max_rsize(map, needed): return the length of the biggest free region
  679. + * in the given memory map, or 0 if no regions remain.
  680. + * needed is minimun amount needed, if != 0 try to keep unattached
  681. + * shared text regions, else count them all as free.
  682. + */
  683. +
  684. +long
  685. +max_rsize(map, needed)
  686. +    MMAP map;
  687. +    long needed;
  688. +{
  689. +    MEMREGION *m;
  690. +    long size = 0, lastsize = 0, end = 0;
  691. +
  692. +    if (needed) {
  693. +        for (m = *map; m; m = m->next) {
  694. +            if (ISFREE(m) ||
  695. +                (m->links == 0xfffe && !(m->mflags & M_SHTEXT))) {
  696. +                if (end == m->loc) {
  697. +                    lastsize += m->len;
  698. +                } else {
  699. +                    lastsize = m->len;
  700. +                }
  701. +                end = m->loc + m->len;
  702. +                if (lastsize > size) {
  703. +                    size = lastsize;
  704. +                }
  705. +            }
  706. +        }
  707. +        if (size >= needed)
  708. +            return size;
  709. +
  710. +        lastsize = end = 0;
  711. +    }
  712. +    for (m = *map; m; m = m->next) {
  713. +        if (ISFREE(m) || m->links == 0xfffe ||
  714. +            (m->links == 0xffff && (m->mflags & M_SHTEXT))) {
  715. +            if (end == m->loc) {
  716. +                lastsize += m->len;
  717. +            } else {
  718. +                lastsize = m->len;
  719. +            }
  720. +            end = m->loc + m->len;
  721. +            if (lastsize > size) {
  722. +                if (needed && lastsize >= needed)
  723. +                    return lastsize;
  724. +                size = lastsize;
  725. +            }
  726. +        }
  727. +    }
  728. +    return size;
  729. +}
  730. +
  731. +/*
  732. + * tot_rsize(map, flag): if flag == 1, return the total number of bytes in
  733. + * the given memory map; if flag == 0, return only the number of free
  734. + * bytes
  735. + */
  736. +
  737. +long
  738. +tot_rsize(map, flag)
  739. +    MMAP map;
  740. +    int flag;
  741. +{
  742. +    MEMREGION *m;
  743. +    long size = 0;
  744. +
  745. +    for (m = *map; m; m = m->next) {
  746. +        if (flag || ISFREE(m) ||
  747. +            (m->links == 0xffff && (m->mflags & M_SHTEXT))) {
  748. +            size += m->len;
  749. +        }
  750. +    }
  751. +    return size;
  752. +}
  753. +#endif
  754.  
  755.  /*
  756.   * alloc_region(MMAP map, ulong size, int mode): allocate a new region and
  757. @@ -979,61 +1112,195 @@
  758.      return m;
  759.  }
  760.  
  761. +static void terminateme(code)
  762. +    int code;
  763. +{
  764. +    Pterm (code);
  765. +}
  766. +
  767.  MEMREGION *
  768. -create_base(cmd, env, flags, prgsize)
  769. +create_base(cmd, env, flags, prgsize, execproc, s, f, fh, xp)
  770.      const char *cmd;
  771.      MEMREGION *env;
  772.      ulong flags, prgsize;
  773. +    PROC *execproc;
  774. +    SHTEXT *s;
  775. +    FILEPTR *f;
  776. +    FILEHEAD *fh;
  777. +    XATTR *xp;
  778.  {
  779. -    long len, coresize, altsize;
  780. +    long len = 0, minalt = 0, coresize, altsize;
  781.      MMAP map;
  782. -    MEMREGION *m;
  783. +    MEMREGION *m, *savemem = 0;
  784.      BASEPAGE *b;
  785. +    PROC *parent = 0;    /* keep compiler happy... */
  786.      short protmode;
  787. +    int i;
  788. +
  789. +/* if we're about to do an exec tell max_rsize which of the exec'ing
  790. +   process regions will be freed, but don't free them yet so the process
  791. +   can still get an ENOMEM...
  792. +*/
  793. +    if (execproc) {
  794. +        for (i = 0; i < execproc->num_reg; i++) {
  795. +            m = execproc->mem[i];
  796. +            if (m && m->links == 1)
  797. +                m->links = 0xfffe;
  798. +        }
  799. +
  800. +/* if parents mem saved because of a blocking fork that can be restored too
  801. +*/
  802. +        if ((parent = pid2proc(execproc->ppid)) &&
  803. +            parent->wait_q == WAIT_Q && 
  804. +            parent->wait_cond == (long)execproc) {
  805. +            for (i = 0; i < parent->num_reg; i++) {
  806. +                m = parent->mem[i];
  807. +                if (m && (m->mflags & M_FSAVED)) {
  808. +                    m->links = 0xfffe;
  809. +                    savemem = m;
  810. +                    break;
  811. +                }
  812. +            }
  813. +        }
  814. +    }
  815.  
  816.  /* if flags & F_ALTLOAD == 1, then we might decide to load in alternate
  817.     RAM if enough is available. "enough" is: if more alt ram than ST ram,
  818.     load there; otherwise, if more than (minalt+1)*128K alt ram available
  819.     for heap space, load in alt ram ("minalt" is the high byte of flags)
  820.   */
  821. +    if (flags & (F_ALTLOAD|F_SHTEXT)) {
  822. +        minalt = (flags & F_MINALT) >> 28L;
  823. +        minalt = len = (minalt+1)*128*1024L + prgsize + 256;
  824. +        if ((flags & F_MINALT) == F_MINALT)
  825. +            len = 0;
  826. +    }
  827.      if (flags & F_ALTLOAD) {
  828. -        coresize = max_rsize(core);
  829. -        altsize = max_rsize(alt);
  830. -        if (altsize >= coresize)
  831. +        coresize = max_rsize(core, len);
  832. +        altsize = max_rsize(alt, len);
  833. +        if (altsize >= coresize) {
  834.              map = alt;
  835. -        else {
  836. -            len = (flags & F_MINALT) >> 28L;
  837. -            len = (len+1)*128*1024L + prgsize + 256;
  838. -            if (altsize >= len)
  839. +            len = altsize;
  840. +        } else {
  841. +            if (altsize >= minalt) {
  842.                  map = alt;
  843. -            else
  844. +                len = altsize;
  845. +            } else {
  846.                  map = core;
  847. +                len = coresize;
  848. +            }
  849.          }
  850.      }
  851.      else
  852. -        map = core;
  853. +        len = max_rsize((map = core), len);
  854.  
  855. -    len = max_rsize(map);
  856. +    if (savemem)
  857. +        savemem->links = 1;
  858.      if (curproc->maxmem && len > curproc->maxmem) {
  859.          len = curproc->maxmem;
  860.      }
  861.  
  862. -    if (len < prgsize) {
  863. -        /* can't possibly load this file in its eligible regions */
  864. -        DEBUG(("create_base: max_rsize smaller than prgsize"));
  865. -        return 0;
  866. -    }
  867. -
  868.  /* make sure that a little bit of memory is left over */
  869.      if (len > 2*KEEP_MEM) {
  870.          len -= KEEP_MEM;
  871.      }
  872. -
  873. +    if (s && !s->text &&
  874. +        (!(flags & F_ALTLOAD) || map == alt || altsize < fh->ftext ||
  875. +         !(s->text = addr2mem(alloc_region(alt, fh->ftext, PROT_P))))) {
  876. +        if (len > fh->ftext + KERNEL_MEM)
  877. +            len -= fh->ftext + KERNEL_MEM;
  878. +        else
  879. +            len = 0;
  880. +    }
  881. +
  882. +    if (prgsize && len < prgsize + 0x400) {
  883. +        /* can't possibly load this file in its eligible regions */
  884. +        DEBUG(("create_base: max_rsize smaller than prgsize"));
  885. +
  886. +        if (execproc) {
  887. +/* error, undo the above */
  888. +            for (i = 0; i < execproc->num_reg; i++) {
  889. +                m = execproc->mem[i];
  890. +                if (m && m->links == 0xfffe)
  891. +                    m->links = 1;
  892. +            }
  893. +        }
  894. +        if (s && !s->text) {
  895. +            kfree (s);
  896. +        }
  897. +        mint_errno = ENSMEM;
  898. +        return 0;
  899. +    }
  900. +    if (execproc) {
  901. +/* free exec'ing process memory... if the exec returns after this make it
  902. +   _exit (SIGKILL << 8);
  903. +*/
  904. +        *((short *) (execproc->stack + ISTKSIZE + sizeof (void (*)()))) =
  905. +            (SIGKILL << 8);
  906. +        execproc->ctxt[SYSCALL].term_vec = (long)rts;
  907. +        execproc->ctxt[SYSCALL].pc = (long)terminateme;
  908. +        execproc->ctxt[SYSCALL].sr |= 0x2000;
  909. +        execproc->ctxt[SYSCALL].ssp = (long)(execproc->stack + ISTKSIZE);
  910. +
  911. +        if (savemem)
  912. +            fork_restore(parent, savemem);
  913. +        for (i = 0; i < execproc->num_reg; i++) {
  914. +            m = execproc->mem[i];
  915. +            if (m && m->links == 0xfffe) {
  916. +                if (m->mflags & M_SHTEXT_T) {
  917. +                    m->links = 0xffff;
  918. +                } else {
  919. +                    m->links = 0;
  920. +                    free_region(m);
  921. +                }
  922. +                execproc->mem[i] = 0;
  923. +                execproc->addr[i] = 0;
  924. +            }
  925. +        }
  926. +    }
  927.      protmode = (flags & F_PROTMODE) >> F_PROTSHIFT;
  928.  
  929. -    m = addr2mem(alloc_region(map, len, protmode));
  930. +    m = 0;
  931. +    if (s && !s->f) {
  932. +        if (!s->text) {
  933. +            m = addr2mem(alloc_region(map, len + fh->ftext + KERNEL_MEM, protmode));
  934. +            if (!m ||
  935. +                (((len > minalt &&
  936. +                ((flags & F_MINALT) < F_MINALT) &&
  937. +                max_rsize (map, -1) < fh->ftext) ||
  938. +                  !(s->text = addr2mem(alloc_region(map, fh->ftext, PROT_P))) ||
  939. +                  (m->next == s->text &&
  940. +                !(detach_region (curproc, s->text), s->text = 0))) &&
  941. +                 shrink_region(m, fh->ftext))) {
  942. +                if (m)
  943. +                    detach_region(curproc, m);
  944. +                kfree (s);
  945. +                mint_errno = ENSMEM;
  946. +                return 0;
  947. +            }
  948. +            if (!s->text) {
  949. +                s->text = m;
  950. +                if (protmode != PROT_P)
  951. +                    change_prot_status (curproc, m->loc, PROT_P);
  952. +                m = 0;
  953. +            }
  954. +        }
  955. +        s = get_text_seg(f, fh, xp, s, 0);
  956. +        if (!s) {
  957. +            if (m)
  958. +                detach_region(curproc, m);
  959. +            DEBUG(("create_base: unable to load shared text segment"));
  960. +/* mint_errno set in get_text_seg */
  961. +            return 0;
  962. +        }
  963. +    }
  964. +
  965. +    if (!m) {
  966. +        m = addr2mem(alloc_region(map, len, protmode));
  967. +    }
  968.      if (!m) {
  969.          DEBUG(("create_base: alloc_region failed"));
  970. +        mint_errno = ENSMEM;
  971.          return 0;
  972.      }
  973.      b = (BASEPAGE *)(m->loc);
  974. @@ -1062,7 +1329,7 @@
  975.   */
  976.  
  977.  MEMREGION *
  978. -load_region(filename, env, cmdlin, xp, text, fp)
  979. +load_region(filename, env, cmdlin, xp, text, fp, isexec)
  980.      const char *filename;
  981.      MEMREGION *env;
  982.      const char *cmdlin;
  983. @@ -1070,6 +1337,7 @@
  984.      MEMREGION **text;    /* set to point to shared text region,
  985.                     if any */
  986.      long *fp;        /* prgflags for this file */
  987. +    int isexec;        /* this is an exec*() (overlay) */
  988.  {
  989.      FILEPTR *f;
  990.      DEVDRV *dev;
  991. @@ -1077,6 +1345,7 @@
  992.      BASEPAGE *b;
  993.      long size, start;
  994.      FILEHEAD fh;
  995. +    SHTEXT *s;
  996.  
  997.  /* bug: this should be O_DENYW mode, not O_DENYNONE */
  998.  /* we must use O_DENYNONE because of the desktop and because of the
  999. @@ -1105,30 +1374,45 @@
  1000.  
  1001.      if (fh.flag & F_SHTEXT) {
  1002.          TRACE(("loading shared text segment"));
  1003. -        shtext = get_text_seg(f, &fh, xp);
  1004. -        if (!shtext) {
  1005. +        s = get_text_seg(f, &fh, xp, 0L, isexec);
  1006. +        if (!s) {
  1007.              DEBUG(("load_region: unable to get shared text segment"));
  1008.  /* mint_errno set in get_text_seg */
  1009.              goto failed;
  1010.          }
  1011.          size = fh.fdata + fh.fbss;
  1012. +        shtext = s->text;
  1013.      } else {
  1014.          size = fh.ftext + fh.fdata + fh.fbss;
  1015.          shtext = 0;
  1016. +        s = 0;
  1017.      }
  1018.  
  1019. -    reg = create_base(cmdlin, env, fh.flag, size);
  1020. +    env->links++;
  1021. +    if (s && !shtext) {
  1022. +        reg = create_base(cmdlin, env, fh.flag, size,
  1023. +            isexec ? curproc : 0L, s, f, &fh, xp);
  1024. +        shtext = s->text;
  1025. +    } else {
  1026. +        if (shtext)
  1027. +            shtext->links++;
  1028. +        reg = create_base(cmdlin, env, fh.flag, size,
  1029. +            isexec ? curproc : 0L, 0L, 0L, 0L, 0L);
  1030. +        if (shtext)
  1031. +            shtext->links--;
  1032. +    }
  1033. +    env->links--;
  1034.      if (reg && size+1024L > reg->len) {
  1035.          DEBUG(("load_region: insufficient memory to load"));
  1036.          detach_region(curproc, reg);
  1037.          reg = 0;
  1038. +        mint_errno = ENSMEM;
  1039.      }
  1040.  
  1041.      if (reg == 0) {
  1042.          if (shtext) {
  1043.              detach_region(curproc, shtext);
  1044.          }
  1045. -        mint_errno = ENSMEM;
  1046.          goto failed;
  1047.      }
  1048.  
  1049. @@ -1294,58 +1578,70 @@
  1050.   * process
  1051.   */
  1052.  
  1053. -MEMREGION *
  1054. -get_text_seg(f, fh, xp)
  1055. +SHTEXT *
  1056. +get_text_seg(f, fh, xp, s, noalloc)
  1057.      FILEPTR *f;
  1058.      FILEHEAD *fh;
  1059.      XATTR *xp;
  1060. -{
  1061.      SHTEXT *s;
  1062. +    int noalloc;
  1063. +{
  1064.      MEMREGION *m;
  1065.      long r;
  1066.      BASEPAGE b;
  1067.  
  1068. -    s = text_reg;
  1069. +    if (s) {
  1070. +        m = s->text;
  1071. +    } else {
  1072. +        s = text_reg;
  1073.  
  1074. -    while(s) {
  1075. -        if (s->f && samefile(&f->fc, &s->f->fc) &&
  1076. -            xp->mtime == s->mtime &&
  1077. -            xp->mdate == s->mdate)
  1078. -        {
  1079. -            m = s->text;
  1080. +        while(s) {
  1081. +            if (s->f && samefile(&f->fc, &s->f->fc) &&
  1082. +                xp->mtime == s->mtime &&
  1083. +                xp->mdate == s->mdate)
  1084. +            {
  1085. +                m = s->text;
  1086.  /* Kludge for unattached shared region */
  1087. -            if (m->links == 0xffff)
  1088. -                m->links = 0;
  1089. +                if (m->links == 0xffff)
  1090. +                    m->links = 0;
  1091.  
  1092. -            if (attach_region(curproc, m)) {
  1093. +                if (attach_region(curproc, m)) {
  1094.  TRACE(("re-using shared text region %lx", m));
  1095. -                return m;
  1096. -            }
  1097. -            else {
  1098. -                mint_errno = ENSMEM;
  1099. -                return 0;
  1100. +                    return s;
  1101. +                }
  1102. +                else {
  1103. +                    mint_errno = ENSMEM;
  1104. +                    return 0;
  1105. +                }
  1106.              }
  1107. +            s = s->next;
  1108.          }
  1109. -        s = s->next;
  1110. -    }
  1111.  
  1112.  /* hmmm, not found; OK, we'll have to create a new text region */
  1113.  
  1114. -    s = kmalloc(SIZEOF(SHTEXT));
  1115. -    if (!s) {
  1116. -        mint_errno = ENSMEM;
  1117. -        return 0;
  1118. +        s = kmalloc(SIZEOF(SHTEXT));
  1119. +        if (!s) {
  1120. +            mint_errno = ENSMEM;
  1121. +            return 0;
  1122. +        }
  1123. +        if (noalloc) {
  1124. +            s->f = 0;
  1125. +            s->text = 0;
  1126. +            return s;
  1127. +        }
  1128. +        m = 0;
  1129.      }
  1130. -    m = 0;
  1131. +    if (!m) {
  1132.  /* actually, I can't see why loading in TT RAM is ever undesireable,
  1133.   * since shared text programs should be very clean (and since only
  1134.   * the text segment is going in there). But better safe than sorry.
  1135.   */
  1136. -    if (fh->flag & F_ALTLOAD) {
  1137. -        m = addr2mem(alloc_region(alt, fh->ftext, PROT_P));
  1138. +        if (fh->flag & F_ALTLOAD) {
  1139. +            m = addr2mem(alloc_region(alt, fh->ftext, PROT_P));
  1140. +        }
  1141. +        if (!m)
  1142. +            m = addr2mem(alloc_region(core, fh->ftext, PROT_P));
  1143.      }
  1144. -    if (!m)
  1145. -        m = addr2mem(alloc_region(core, fh->ftext, PROT_P));
  1146.  
  1147.      if (!m) {
  1148.          kfree(s);
  1149. @@ -1375,6 +1671,11 @@
  1150.  
  1151.  /* region has valid shared text data */
  1152.      m->mflags |= M_SHTEXT;
  1153. +#if 1
  1154. +    if (xp->mode & 01000)
  1155. +#endif
  1156. +/* make it sticky (this should depend on the files mode!?) */
  1157. +    m->mflags |= M_SHTEXT_T;
  1158.  
  1159.  /*
  1160.   * KLUDGE: to make sure we always have up to date shared text
  1161. @@ -1395,7 +1696,25 @@
  1162.      s->mdate = xp->mdate;
  1163.      text_reg = s;
  1164.  TRACE(("shared text region %lx created", m));
  1165. -    return m;
  1166. +    return s;
  1167. +}
  1168. +
  1169. +/*
  1170. + * function to just check for existence of a shared text region
  1171. + * corresponding to file "f"
  1172. + */
  1173. +
  1174. +MEMREGION *
  1175. +find_text_seg(f)
  1176. +    FILEPTR *f;
  1177. +{
  1178. +    SHTEXT *s;
  1179. +
  1180. +    for (s = text_reg; s; s = s->next) {
  1181. +        if (s->f && samefile(&f->fc, &s->f->fc))
  1182. +            return s->text;
  1183. +    }
  1184. +    return 0;
  1185.  }
  1186.  
  1187.  /*
  1188. Index: mem.h
  1189. @@ -25,6 +25,8 @@
  1190.  #define M_MAP        0x0f    /* and with this to pick out map */
  1191.  
  1192.  #define M_SHTEXT    0x10    /* region is a shared text region */
  1193. +#define M_SHTEXT_T    0x20    /* `sticky bit' for shared text regions */
  1194. +#define M_FSAVED    0x40    /* region is saved memory of a forked process */
  1195.  #define M_KEEP        0x0100    /* don't free on process termination */
  1196.  
  1197.  /* dummy type for virtual addresses */
  1198. Index: proto.h
  1199. @@ -154,6 +154,7 @@
  1200.  long ARGS_ON_STACK p_waitpid P_((int pid, int nohang, long *rusage));
  1201.  long ARGS_ON_STACK p_wait3 P_((int nohang, long *rusage));
  1202.  long ARGS_ON_STACK p_wait P_((void));
  1203. +void ARGS_ON_STACK fork_restore P_((PROC *p, MEMREGION *savemem));
  1204.  long ARGS_ON_STACK p_vfork P_((void));
  1205.  long ARGS_ON_STACK p_fork P_((void));
  1206.  
  1207. @@ -217,14 +218,16 @@
  1208.  MEMREGION *get_region P_((MMAP map, ulong size, int mode));
  1209.  void free_region P_((MEMREGION *reg));
  1210.  long shrink_region P_((MEMREGION *reg, ulong newsize));
  1211. -long max_rsize P_((MMAP map));
  1212. +long max_rsize P_((MMAP map, long needed));
  1213.  long tot_rsize P_((MMAP map, int flag));
  1214.  virtaddr alloc_region P_((MMAP map, ulong size, int mode));
  1215.  MEMREGION *create_env P_((const char *env, ulong flags));
  1216. -MEMREGION *create_base P_((const char *cmd, MEMREGION *env, ulong flags, ulong prgsize));
  1217. +MEMREGION *create_base P_((const char *cmd, MEMREGION *env, ulong flags, ulong prgsize,
  1218. +            PROC *execproc, SHTEXT *s, FILEPTR *f, FILEHEAD *fh, XATTR *xp));
  1219.  MEMREGION *load_region P_((const char *name, MEMREGION *env, const char *cmdlin, XATTR *x,
  1220. -            MEMREGION **text, long *fp));
  1221. -MEMREGION *get_text_seg P_((FILEPTR *f, FILEHEAD *fh, XATTR *xp));
  1222. +            MEMREGION **text, long *fp, int isexec));
  1223. +SHTEXT *get_text_seg P_((FILEPTR *f, FILEHEAD *fh, XATTR *xp, SHTEXT *s, int noalloc));
  1224. +MEMREGION *find_text_seg P_((FILEPTR *f));
  1225.  long load_and_reloc P_((FILEPTR *f, FILEHEAD *fh, char *where, long start,
  1226.              long nbytes, BASEPAGE *base));
  1227.  void rts P_((void));
  1228. -- 
  1229. J"urgen Lock / nox@jelal.north.de / UUCP: ..!uunet!unido!uniol!jelal!nox
  1230.                                 ...ohne Gewehr
  1231. PGP public key fingerprint =  8A 18 58 54 03 7B FC 12  1F 8B 63 C7 19 27 CF DA 
  1232.